const { setType, setAiValueForMonitor, getAiValueForMonitor, getImage, setMeterStats, setImage, ismonitorID } = require("../models/redisModel");
const { meterMode } = require("../models/meterMode");
const {associateDeviceWithToken, associateDeviceWithUser} = require("./interactionServer");
const redisClient = require("../utils/redisClient");
const IndicatorMeterInfo = require("../models/db/IndicatorMeterInfo");


/**
 * 创建监控
 * @param {string} type - 仪表类型（如 "Ammeter", "PressureMeter" 等）
 * @param {string} meter_id - 仪表 ID
 * @param {string} monitor_id - 监控 ID
 * @param token
 * @returns {Promise<{success: boolean, data?: string, message?: string}>} - 返回创建结果
 */
async function createMonitor(type, meter_id, monitor_id, token) {
    try {
        // 检查是否支持的表类型
        if (!meterMode[type]) {
            return { success: false, message: `监控创建失败: 不支持的表类型 ${type}` };
        }

        // 检查监控 ID 是否已存在
        const ismonitor_id = await ismonitorID(monitor_id);
        if (ismonitor_id) {
            return { success: false, message: `监控创建失败: 监控名称 ${monitor_id} 已存在` };
        }

        // 查找对应的表记录
        const instance = await meterMode[type].findOne({ where: { id: meter_id } });
        if (!instance) {
            return { success: false, message: `未找到类型 ${type} 下的表记录 id: ${meter_id}` };
        }

        // 更新数据库，将监控 ID 绑定到仪表记录
        await instance.update({ monitorId: monitor_id });

        // 建立 Redis 监控与表类型的关系
        await setType(monitor_id, type);

        // 对特定类型（如 Pressure 或 Temperature），建立监控与量程的关系
        if (type === "Pressure" || type === "Temperature") {
            await setMeterStats(monitor_id, instance.range);
        }

        // 初始化 Redis 中监控的 AI 值和图片
        await setAiValueForMonitor(monitor_id);
        await setImage(monitor_id);

        // 设备与 用户 关系
        const username = await redisClient.hGet('user_tokens', token);
        await associateDeviceWithUser(monitor_id, username)


        // 返回成功信息
        return { success: true, data: `创建成功: ${type} 表 id: ${meter_id} 下的监控 id: ${monitor_id}` };
    } catch (error) {
        return { success: false, message: `创建失败: ${error.message}` };
    }
}



/**
 * 获取某类型的所有表信息
 * @param {string} type - 仪表类型
 * @returns {Promise<{success: boolean, data?: Array, message?: string}>} - 返回表信息列表
 */
async function getTypeMeterInfo(type ) {
    try {
        // 检查是否支持的表类型
        if (!meterMode[type]) {
            return { success: false, message: `不支持的表类型 ${type}` };
        }

        // 查询该类型的所有表信息
        const meterInfoList = await meterMode[type].findAll();

        if (!meterInfoList || meterInfoList.length === 0) {
            return { success: false, message: `未找到类型 ${type} 的表信息` };
        }

        // 获取每个表的详细信息（包括 AI 值和单位）
        const result = await Promise.all(
            meterInfoList.map(async (meterInfo) => {
                const unit = meterInfo.unit ? meterInfo.unit : null;
                const aiValue = meterInfo.monitorId ? await getAiValueForMonitor(meterInfo.monitorId , meterInfo.username) : null;
                return {
                    meterId: meterInfo.id,
                    alias: meterInfo.alias,
                    monitorId: meterInfo.monitorId,
                    unit: unit,
                    aiValue,
                };
            })
        );

        return { success: true, data: result };
    } catch (error) {
        return { success: false, message: `获取表信息失败: ${error.message}` };
    }
}



/**
 * 获取单个表的信息
 * @param {string} type - 仪表类型
 * @param {string} meter_id - 仪表 ID
 * @returns {Promise<{success: boolean, data?: Object, message?: string}>} - 返回表详细信息
 */
async function getSingleMonitorInfo(type, meter_id) {
    try {
        // 检查是否支持的表类型
        if (!meterMode[type]) {
            return { success: false, message: `不支持的表类型 ${type}` };
        }

        // 查询表信息
        const meterInfo = await meterMode[type].findOne({ where: { id: meter_id } });
        if (!meterInfo) {
            return { success: false, message: `未找到类型 ${type} 下的表 id: ${meter_id}` };
        }

        // 获取单位、AI 值和图片信息
        const unit = meterInfo.unit ? meterInfo.unit : null;
        const aiValue = meterInfo.monitorId ? await getAiValueForMonitor(meterInfo.monitorId  , meterInfo.username) : null;
        const imageInfo = meterInfo.monitorId ? await getImage(meterInfo.monitorId) : null;

        return {
            success: true,
            data: {
                meterId: meter_id,
                alias: meterInfo.alias,
                monitorId: meterInfo.monitorId,
                unit: unit,
                aiValue,
                image_path: imageInfo || null,
            },
        };
    } catch (error) {
        return { success: false, message: `获取表信息失败: ${error.message}` };
    }
}



/**
 * 获取单个监控的详细信息
 * @param {string} monitor_id - 监控 ID
 * @returns {Promise<{success: boolean, data?: Object, message?: string}>} - 返回监控详细信息
 */
async function getMonitorInfo(monitor_id) {
    try {
        // 获取 AI 值和图片信息
        const username = await redisClient.hGet('monitor_user', monitor_id);

        const aiValue = await getAiValueForMonitor(monitor_id , username );
        const imageInfo = await getImage(monitor_id);

        return {
            success: true,
            data: {
                monitorId: monitor_id,
                aiValue: aiValue || null,
                image_path: imageInfo || null,
            },
        };
    } catch (error) {
        return { success: false, message: `获取监控信息失败: ${error.message}` };
    }
}



// 图片
async function setImgData(monitor_id) {
    try {
        // 获取 AI 值和图片信息
        const image = await redisClient.hGet('Image', monitor_id);
        return {
            success: true,
            data: {
                monitorId: monitor_id,
                image_path: image || null,
            },
        };
    } catch (error) {
        return { success: false, message: `获取监控信息失败: ${error.message}` };
    }
}

// 标注数据
async function setIndicator(monitor_id, data) {
    try {
        const indicator_redis_data = await redisClient.hSet('indicator', monitor_id , data);
        const updateResult = await IndicatorMeterInfo.update(
            { labels: data }, // 要更新的字段和值
            { where: { monitorId: monitor_id } } // 更新条件
        );
        return {
            success: true,
            data: {
                monitorId: monitor_id,
                updatedRecords: updateResult.labels, // 返回更新的记录数
            },
        };
    } catch (error) {
        return { success: false, message: `获取监控信息失败: ${error.message}` };
    }
}



/**
 * 搜索框查询
 * @param {string} type - 仪表类型
 * @param {string} [meterId] - 仪表 ID（可选）
 * @param {string} [alias] - 仪表别名（可选）
 * @param {string} [monitorId] - 监控 ID（可选）
 * @returns {Promise<{success: boolean, data?: Array, message?: string}>} - 返回查询结果
 */
async function queryMeter(type, meterId, alias, monitorId) {
    try {
        // 获取所有表信息
        const meterInfoResponse = await getTypeMeterInfo(type);
        const meterInfoList = Array.isArray(meterInfoResponse.data) ? meterInfoResponse.data : [];

        if (meterInfoList.length === 0) {
            return { success: false, message: `未找到类型 ${type} 的表信息` };
        }

        // 根据提供的参数进行过滤
        const filteredMeters = meterInfoList.filter(meter => {
            return (!meterId || meter.meterId === meterId) &&
                (!alias || (meter.alias && meter.alias.includes(alias))) &&
                (!monitorId || meter.monitorId === monitorId);
        });

        if (filteredMeters.length === 0) {
            return { success: false, message: `未找到符合条件的表信息` };
        }

        // 获取每个表的详细信息（包括 AI 值和单位）
        const result = await Promise.all(
            filteredMeters.map(async (meterInfo) => {
                try {
                    const unit = meterInfo.unit || null;
                    const aiValue = meterInfo.monitorId
                        ? await getAiValueForMonitor(meterInfo.monitorId, meterInfo.username)
                        : null;

                    return {
                        meterId: meterInfo.meterId,
                        alias: meterInfo.alias,
                        monitorId: meterInfo.monitorId,
                        unit: unit,
                        aiValue,
                    };
                } catch (error) {
                    console.error(`获取仪表 ${meterInfo.meterId} 的 AI 值失败:`, error);
                    return {
                        meterId: meterInfo.meterId,
                        alias: meterInfo.alias,
                        monitorId: meterInfo.monitorId,
                        unit: meterInfo.unit || null,
                        aiValue: null,
                        error: `获取 AI 值失败: ${error.message}`,
                    };
                }
            })
        );

        return { success: true, data: result };
    } catch (error) {
        console.error('查询表信息失败:', error);
        return { success: false, message: `查询失败: ${error.message}` };
    }
}



module.exports = {
    createMonitor,
    getTypeMeterInfo,
    getSingleMonitorInfo,
    getMonitorInfo,
    queryMeter,
    setIndicator,
    setImgData
};


